package test;

import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.*;
import java.util.stream.Collector;
import java.util.stream.Stream;

@Slf4j
public class T01 {
    @Test
    public void tConsumer() {
        Consumer f = System.out::println;

        Consumer f2 = n -> System.out.println(n + "-F2");

        //执行完F后再执行F2的Accept方法
        f.andThen(f2).accept("test");
        log.info("-----");
        //连续执行F的Accept方法
        f.accept("test1");
        f.andThen(f);
    }

    @Test
    public  void tFunction(){
        Function<Integer, Integer> f = s -> s*10;
        Function<Integer, Integer> g = s -> s * 2;
        Function<Integer, Integer> a = s -> s /4;
//        先执行G，并且执行F时使用G的输出当作输入
        log.info(g.apply(1)+"---");
        log.info(f.apply(1)+"---");

        System.out.println(f.compose(g).andThen(a).apply(1));

    }

@Test
    public void tPredicate(){
        Predicate<String> p = o -> o.equals("test");
        Predicate<String> g = o -> o.startsWith("t");

        /**
         * negate: 用于对原来的Predicate做取反处理；
         * 如当调用p.test("test")为True时，调用p.negate().test("test")就会是False；
         */
        Assert.assertFalse(p.negate().test("test"));

        /**
         * and: 针对同一输入值，多个Predicate均返回True时返回True，否则返回False；
         */
        Assert.assertTrue(p.and(g).test("test"));

        /**
         * or: 针对同一输入值，多个Predicate只要有一个返回True则返回True，否则返回False
         */
        Assert.assertTrue(p.or(g).test("ta"));

    }
    @Test
    public  void tStream(){
//        Stream.iterate(1,
//                new Predicate<Integer>() {
//                    @Override
//                    public boolean test(Integer integer) {
//                        return integer <= 10;
//                    }
//                },
//                new UnaryOperator<Integer>() {
//                    @Override
//                    public Integer apply(Integer integer) {
//                        return integer+1;
//                    }
//                }).forEach(System.out::println);
        Stream.iterate(1,new UnaryOperator<Integer>() {
                    @Override
                    public Integer apply(Integer integer) {
                        return integer+1;
                    }
                }).filter(i->i<=10).forEach(System.out::println);


    }
}